
# 添加任务依赖功能, 同任务流依赖

import threading
import time
import logging

class TaskScheduler:
    def __init__(self):
        self.condition = threading.Condition()
        self.ready = False
        self.task_flows = {}
        self.task_flow_events = {}
        self.task_dependencies = {}
        self.task_completion = {}

    def wait_for_ready(self):
        with self.condition:
            while not self.ready:
                self.condition.wait()
            print("条件满足，开始执行任务流")
            logging.info("条件满足，开始执行任务流")

    def set_ready(self):
        with self.condition:
            self.ready = True
            self.condition.notify_all()

    def add_task_flow(self, task_flow_name, tasks, dependencies=None):
        with self.condition:
            self.task_flows[task_flow_name] = tasks
            self.task_flow_events[task_flow_name] = threading.Event()
            self.task_dependencies[task_flow_name] = dependencies if dependencies else {}
            self.task_completion[task_flow_name] = {task.__name__: False for task in tasks}
            print(f"任务流 {task_flow_name} 已添加")
            logging.info(f"任务流 {task_flow_name} 已添加")

    def remove_task_flow(self, task_flow_name):
        with self.condition:
            if task_flow_name in self.task_flows:
                del self.task_flows[task_flow_name]
                del self.task_flow_events[task_flow_name]
                del self.task_dependencies[task_flow_name]
                del self.task_completion[task_flow_name]
                print(f"任务流 {task_flow_name} 已删除")
                logging.info(f"任务流 {task_flow_name} 已删除")
            else:
                print(f"任务流 {task_flow_name} 不存在")
                logging.info(f"任务流 {task_flow_name} 不存在")

    def set_task_flow_ready(self, task_flow_name):
        self.task_flow_events[task_flow_name].set()
        print(f"任务流 {task_flow_name} 的条件已满足")
        logging.info(f"任务流 {task_flow_name} 的条件已满足")

    def run_task_flow(self, task_flow_name):
        while True:
            self.task_flow_events[task_flow_name].wait()
            if not self.task_flows[task_flow_name]:
                print(f"任务流 {task_flow_name} 为空，等待新任务")
                logging.info(f"任务流 {task_flow_name} 为空，等待新任务")
                self.task_flow_events[task_flow_name].clear()
                continue

            for task in self.task_flows[task_flow_name]:
                task_name = task.__name__
                if all(self.task_completion[task_flow_name].get(dep, False) for dep in self.task_dependencies[task_flow_name].get(task_name, [])):
                    task()
                    self.task_completion[task_flow_name][task_name] = True
                    print(f"任务 {task_name} 执行完成")
                    logging.info(f"任务 {task_name} 执行完成")
                else:
                    print(f"任务 {task_name} 的依赖任务未完成，等待中...")
                    logging.info(f"任务 {task_name} 的依赖任务未完成，等待中...")

            if all(self.task_completion[task_flow_name].values()):
                self.task_flow_events[task_flow_name].clear()

    def start(self):
        # 创建并启动等待条件的线程
        waiting_thread = threading.Thread(target=self.wait_for_ready)
        waiting_thread.start()

        # 创建并启动每个任务流的线程
        for task_flow_name, tasks in self.task_flows.items():
            task_thread = threading.Thread(target=self.run_task_flow, args=(task_flow_name,))
            task_thread.start()

        # 不再等待 waiting_thread，避免主线程阻塞
        # waiting_thread.join()

# 定义一些示例任务
def task1():
    print("执行任务 1")

def task2():
    print("执行任务 2")

def task3():
    print("执行任务 3")

def task4():
    print("执行任务 4")

# 使用示例
if __name__ == "__main__":
    logging.basicConfig(level=logging.INFO)

    scheduler = TaskScheduler()

    # 添加任务流
    scheduler.add_task_flow("flow1", [task1, task2], dependencies={"task2": ["task1"]})
    scheduler.add_task_flow("flow2", [task3, task4], dependencies={"task4": ["task3"]})

    # 启动调度器
    scheduler.start()

    # 模拟条件变为 True
    time.sleep(2)  # 模拟等待时间
    scheduler.set_ready()

    # 动态设置任务流条件
    time.sleep(2)
    scheduler.set_task_flow_ready("flow1")

    time.sleep(2)
    scheduler.set_task_flow_ready("flow2")

    # 等待一段时间，确保任务流执行完成
    time.sleep(10)